home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 2000 October / Software of the Month - Ultimate Collection Shareware 277.iso / pc / PROGRAMS / UTILITY / WINLINUX / DATA1.CAB / programs_-_include / ASM-PPC / DMA.H < prev    next >
C/C++ Source or Header  |  1999-09-17  |  13KB  |  436 lines
  1. /* $Id: dma.h,v 1.3 1997/03/16 06:20:39 cort Exp $
  2.  * linux/include/asm/dma.h: Defines for using and allocating dma channels.
  3.  * Written by Hennus Bergman, 1992.
  4.  * High DMA channel support & info by Hannu Savolainen
  5.  * and John Boyd, Nov. 1992.
  6.  * Changes for ppc sound by Christoph Nadig
  7.  */
  8.  
  9. #include <linux/config.h>
  10. #include <asm/io.h>
  11. #include <asm/spinlock.h>
  12. #include <asm/system.h>
  13.  
  14. /*
  15.  * Note: Adapted for PowerPC by Gary Thomas
  16.  * Modified by Cort Dougan <cort@cs.nmt.edu>
  17.  *
  18.  * None of this really applies for Power Macintoshes.  There is
  19.  * basically just enough here to get kernel/dma.c to compile.
  20.  *
  21.  * There may be some comments or restrictions made here which are
  22.  * not valid for the PReP platform.  Take what you read
  23.  * with a grain of salt.
  24.  */
  25.  
  26.  
  27. #ifndef _ASM_DMA_H
  28. #define _ASM_DMA_H
  29.  
  30. #ifndef MAX_DMA_CHANNELS
  31. #define MAX_DMA_CHANNELS    8
  32. #endif
  33.  
  34. /* The maximum address that we can perform a DMA transfer to on this platform */
  35. /* Doesn't really apply... */
  36. #define MAX_DMA_ADDRESS      0xFFFFFFFF
  37.  
  38. #if defined(CONFIG_MACH_SPECIFIC)
  39.  
  40. #if defined(CONFIG_PREP)
  41. #define DMA_MODE_READ 0x44
  42. #define DMA_MODE_WRITE 0x48
  43. #define ISA_DMA_THRESHOLD 0x00ffffff
  44. #endif /* CONFIG_PREP */
  45.  
  46. #if defined(CONFIG_CHRP)
  47. #define DMA_MODE_READ 0x44
  48. #define DMA_MODE_WRITE 0x48
  49. #define ISA_DMA_THRESHOLD ~0L
  50. #endif /* CONFIG_CHRP */
  51.  
  52. #ifdef CONFIG_PMAC
  53. #define DMA_MODE_READ 1
  54. #define DMA_MODE_WRITE 2
  55. #define ISA_DMA_THRESHOLD ~0L
  56. #endif /* CONFIG_PMAC */
  57.  
  58. #ifdef CONFIG_APUS
  59. /* This is bogus and should go away. */
  60. #define ISA_DMA_THRESHOLD (0x00ffffff)
  61. #endif
  62.  
  63. #else
  64. /* in arch/ppc/kernel/setup.c -- Cort */
  65. extern unsigned long DMA_MODE_WRITE, DMA_MODE_READ;
  66. extern unsigned long ISA_DMA_THRESHOLD;
  67. #endif
  68.  
  69.  
  70. #ifdef HAVE_REALLY_SLOW_DMA_CONTROLLER
  71. #define dma_outb    outb_p
  72. #else
  73. #define dma_outb    outb
  74. #endif
  75.  
  76. #define dma_inb        inb
  77.  
  78. /*
  79.  * NOTES about DMA transfers:
  80.  *
  81.  *  controller 1: channels 0-3, byte operations, ports 00-1F
  82.  *  controller 2: channels 4-7, word operations, ports C0-DF
  83.  *
  84.  *  - ALL registers are 8 bits only, regardless of transfer size
  85.  *  - channel 4 is not used - cascades 1 into 2.
  86.  *  - channels 0-3 are byte - addresses/counts are for physical bytes
  87.  *  - channels 5-7 are word - addresses/counts are for physical words
  88.  *  - transfers must not cross physical 64K (0-3) or 128K (5-7) boundaries
  89.  *  - transfer count loaded to registers is 1 less than actual count
  90.  *  - controller 2 offsets are all even (2x offsets for controller 1)
  91.  *  - page registers for 5-7 don't use data bit 0, represent 128K pages
  92.  *  - page registers for 0-3 use bit 0, represent 64K pages
  93.  *
  94.  * On PReP, DMA transfers are limited to the lower 16MB of _physical_ memory.  
  95.  * On CHRP, the W83C553F (and VLSI Tollgate?) support full 32 bit addressing.
  96.  * Note that addresses loaded into registers must be _physical_ addresses,
  97.  * not logical addresses (which may differ if paging is active).
  98.  *
  99.  *  Address mapping for channels 0-3:
  100.  *
  101.  *   A23 ... A16 A15 ... A8  A7 ... A0    (Physical addresses)
  102.  *    |  ...  |   |  ... |   |  ... |
  103.  *    |  ...  |   |  ... |   |  ... |
  104.  *    |  ...  |   |  ... |   |  ... |
  105.  *   P7  ...  P0  A7 ... A0  A7 ... A0   
  106.  * |    Page    | Addr MSB | Addr LSB |   (DMA registers)
  107.  *
  108.  *  Address mapping for channels 5-7:
  109.  *
  110.  *   A23 ... A17 A16 A15 ... A9 A8 A7 ... A1 A0    (Physical addresses)
  111.  *    |  ...  |   \   \   ... \  \  \  ... \  \
  112.  *    |  ...  |    \   \   ... \  \  \  ... \  (not used)
  113.  *    |  ...  |     \   \   ... \  \  \  ... \
  114.  *   P7  ...  P1 (0) A7 A6  ... A0 A7 A6 ... A0   
  115.  * |      Page      |  Addr MSB   |  Addr LSB  |   (DMA registers)
  116.  *
  117.  * Again, channels 5-7 transfer _physical_ words (16 bits), so addresses
  118.  * and counts _must_ be word-aligned (the lowest address bit is _ignored_ at
  119.  * the hardware level, so odd-byte transfers aren't possible).
  120.  *
  121.  * Transfer count (_not # bytes_) is limited to 64K, represented as actual
  122.  * count - 1 : 64K => 0xFFFF, 1 => 0x0000.  Thus, count is always 1 or more,
  123.  * and up to 128K bytes may be transferred on channels 5-7 in one operation. 
  124.  *
  125.  */
  126.  
  127. /* used in nasty hack for sound - see prep_setup_arch() -- Cort */
  128. extern long ppc_cs4232_dma, ppc_cs4232_dma2;
  129. #ifdef CONFIG_CS4232
  130. #define SND_DMA1 ppc_cs4232_dma
  131. #define SND_DMA2 ppc_cs4232_dma2
  132. #else
  133. #ifdef CONFIG_MSS
  134. #define SND_DMA1 CONFIG_MSS_DMA
  135. #define SND_DMA2 CONFIG_MSS_DMA2
  136. #else
  137. #define SND_DMA1 -1
  138. #define SND_DMA2 -1
  139. #endif
  140. #endif
  141.  
  142. /* 8237 DMA controllers */
  143. #define IO_DMA1_BASE    0x00    /* 8 bit slave DMA, channels 0..3 */
  144. #define IO_DMA2_BASE    0xC0    /* 16 bit master DMA, ch 4(=slave input)..7 */
  145.  
  146. /* DMA controller registers */
  147. #define DMA1_CMD_REG        0x08    /* command register (w) */
  148. #define DMA1_STAT_REG        0x08    /* status register (r) */
  149. #define DMA1_REQ_REG            0x09    /* request register (w) */
  150. #define DMA1_MASK_REG        0x0A    /* single-channel mask (w) */
  151. #define DMA1_MODE_REG        0x0B    /* mode register (w) */
  152. #define DMA1_CLEAR_FF_REG    0x0C    /* clear pointer flip-flop (w) */
  153. #define DMA1_TEMP_REG           0x0D    /* Temporary Register (r) */
  154. #define DMA1_RESET_REG        0x0D    /* Master Clear (w) */
  155. #define DMA1_CLR_MASK_REG       0x0E    /* Clear Mask */
  156. #define DMA1_MASK_ALL_REG       0x0F    /* all-channels mask (w) */
  157.  
  158. #define DMA2_CMD_REG        0xD0    /* command register (w) */
  159. #define DMA2_STAT_REG        0xD0    /* status register (r) */
  160. #define DMA2_REQ_REG            0xD2    /* request register (w) */
  161. #define DMA2_MASK_REG        0xD4    /* single-channel mask (w) */
  162. #define DMA2_MODE_REG        0xD6    /* mode register (w) */
  163. #define DMA2_CLEAR_FF_REG    0xD8    /* clear pointer flip-flop (w) */
  164. #define DMA2_TEMP_REG           0xDA    /* Temporary Register (r) */
  165. #define DMA2_RESET_REG        0xDA    /* Master Clear (w) */
  166. #define DMA2_CLR_MASK_REG       0xDC    /* Clear Mask */
  167. #define DMA2_MASK_ALL_REG       0xDE    /* all-channels mask (w) */
  168.  
  169. #define DMA_ADDR_0              0x00    /* DMA address registers */
  170. #define DMA_ADDR_1              0x02
  171. #define DMA_ADDR_2              0x04
  172. #define DMA_ADDR_3              0x06
  173. #define DMA_ADDR_4              0xC0
  174. #define DMA_ADDR_5              0xC4
  175. #define DMA_ADDR_6              0xC8
  176. #define DMA_ADDR_7              0xCC
  177.  
  178. #define DMA_CNT_0               0x01    /* DMA count registers */
  179. #define DMA_CNT_1               0x03
  180. #define DMA_CNT_2               0x05
  181. #define DMA_CNT_3               0x07
  182. #define DMA_CNT_4               0xC2
  183. #define DMA_CNT_5               0xC6
  184. #define DMA_CNT_6               0xCA
  185. #define DMA_CNT_7               0xCE
  186.  
  187. #define DMA_LO_PAGE_0              0x87    /* DMA page registers */
  188. #define DMA_LO_PAGE_1              0x83
  189. #define DMA_LO_PAGE_2              0x81
  190. #define DMA_LO_PAGE_3              0x82
  191. #define DMA_LO_PAGE_5              0x8B
  192. #define DMA_LO_PAGE_6              0x89
  193. #define DMA_LO_PAGE_7              0x8A
  194.  
  195. #define DMA_HI_PAGE_0              0x487    /* DMA page registers */
  196. #define DMA_HI_PAGE_1              0x483
  197. #define DMA_HI_PAGE_2              0x481
  198. #define DMA_HI_PAGE_3              0x482
  199. #define DMA_HI_PAGE_5              0x48B
  200. #define DMA_HI_PAGE_6              0x489
  201. #define DMA_HI_PAGE_7              0x48A
  202.  
  203. #define DMA1_EXT_REG               0x40B
  204. #define DMA2_EXT_REG               0x4D6
  205.  
  206. #define DMA_MODE_CASCADE 0xC0   /* pass thru DREQ->HRQ, DACK<-HLDA only */
  207. #define DMA_AUTOINIT    0x10
  208.  
  209. extern spinlock_t  dma_spin_lock;
  210.  
  211. static __inline__ unsigned long claim_dma_lock(void)
  212. {
  213.     unsigned long flags;
  214.     spin_lock_irqsave(&dma_spin_lock, flags);
  215.     return flags;
  216. }
  217.  
  218. static __inline__ void release_dma_lock(unsigned long flags)
  219. {
  220.     spin_unlock_irqrestore(&dma_spin_lock, flags);
  221. }
  222.  
  223. /* enable/disable a specific DMA channel */
  224. static __inline__ void enable_dma(unsigned int dmanr)
  225. {
  226.     /*
  227.      * The Radstone PPC2 and PPC2a boards have inverted DREQ
  228.      * lines (active low) so each command needs to be logically
  229.      * ORed with 0x40
  230.      */
  231.     unsigned char ucDmaCmd=0x00;
  232.  
  233.     if(_prep_type==_PREP_Radstone)
  234.     {
  235.         switch(ucSystemType)
  236.         {
  237.             case RS_SYS_TYPE_PPC2:
  238.             case RS_SYS_TYPE_PPC2a:
  239.             case RS_SYS_TYPE_PPC2ep:
  240.             {
  241.                 /*
  242.                  * DREQ lines are active low
  243.                  */
  244.                 ucDmaCmd=0x40;
  245.                 break;
  246.             }
  247.  
  248.             default:
  249.             {
  250.                 /*
  251.                  * DREQ lines are active high
  252.                  */
  253.                 break;
  254.             }
  255.         }
  256.     }
  257.  
  258.     if (dmanr != 4)
  259.     {
  260.         dma_outb(0, DMA2_MASK_REG);  /* This may not be enabled */
  261.         dma_outb(ucDmaCmd, DMA2_CMD_REG);  /* Enable group */
  262.     }
  263.     if (dmanr<=3)
  264.     {
  265.         dma_outb(dmanr,  DMA1_MASK_REG);
  266.         dma_outb(ucDmaCmd, DMA1_CMD_REG);  /* Enable group */
  267.     } else
  268.     {
  269.         dma_outb(dmanr & 3,  DMA2_MASK_REG);
  270.     }
  271. }
  272.  
  273. static __inline__ void disable_dma(unsigned int dmanr)
  274. {
  275.     if (dmanr<=3)
  276.         dma_outb(dmanr | 4,  DMA1_MASK_REG);
  277.     else
  278.         dma_outb((dmanr & 3) | 4,  DMA2_MASK_REG);
  279. }
  280.  
  281. /* Clear the 'DMA Pointer Flip Flop'.
  282.  * Write 0 for LSB/MSB, 1 for MSB/LSB access.
  283.  * Use this once to initialize the FF to a known state.
  284.  * After that, keep track of it. :-)
  285.  * --- In order to do that, the DMA routines below should ---
  286.  * --- only be used while interrupts are disabled! ---
  287.  */
  288. static __inline__ void clear_dma_ff(unsigned int dmanr)
  289. {
  290.     if (dmanr<=3)
  291.         dma_outb(0,  DMA1_CLEAR_FF_REG);
  292.     else
  293.         dma_outb(0,  DMA2_CLEAR_FF_REG);
  294. }
  295.  
  296. /* set mode (above) for a specific DMA channel */
  297. static __inline__ void set_dma_mode(unsigned int dmanr, char mode)
  298. {
  299.     if (dmanr<=3)
  300.         dma_outb(mode | dmanr,  DMA1_MODE_REG);
  301.     else
  302.         dma_outb(mode | (dmanr&3),  DMA2_MODE_REG);
  303. }
  304.  
  305. /* Set only the page register bits of the transfer address.
  306.  * This is used for successive transfers when we know the contents of
  307.  * the lower 16 bits of the DMA current address register, but a 64k boundary
  308.  * may have been crossed.
  309.  */
  310. static __inline__ void set_dma_page(unsigned int dmanr, int pagenr)
  311. {
  312.     switch(dmanr) {
  313.         case 0:
  314.             dma_outb(pagenr, DMA_LO_PAGE_0);
  315.                         dma_outb(pagenr>>8, DMA_HI_PAGE_0);
  316.             break;
  317.         case 1:
  318.             dma_outb(pagenr, DMA_LO_PAGE_1);
  319.                         dma_outb(pagenr>>8, DMA_HI_PAGE_1);
  320.             break;
  321.         case 2:
  322.             dma_outb(pagenr, DMA_LO_PAGE_2);
  323.             dma_outb(pagenr>>8, DMA_HI_PAGE_2); 
  324.             break;
  325.         case 3:
  326.             dma_outb(pagenr, DMA_LO_PAGE_3);
  327.             dma_outb(pagenr>>8, DMA_HI_PAGE_3); 
  328.             break;
  329.             case 5:
  330.                 if (SND_DMA1 == 5 || SND_DMA2 == 5)
  331.                 dma_outb(pagenr, DMA_LO_PAGE_5);
  332.             else
  333.                 dma_outb(pagenr & 0xfe, DMA_LO_PAGE_5);
  334.                         dma_outb(pagenr>>8, DMA_HI_PAGE_5);
  335.             break;
  336.         case 6:
  337.                 if (SND_DMA1 == 6 || SND_DMA2 == 6)
  338.                 dma_outb(pagenr, DMA_LO_PAGE_6);
  339.             else
  340.                 dma_outb(pagenr & 0xfe, DMA_LO_PAGE_6);
  341.             dma_outb(pagenr>>8, DMA_HI_PAGE_6);
  342.             break;
  343.         case 7:
  344.             if (SND_DMA1 == 7 || SND_DMA2 == 7)
  345.                 dma_outb(pagenr, DMA_LO_PAGE_7);
  346.             else
  347.                 dma_outb(pagenr & 0xfe, DMA_LO_PAGE_7);
  348.             dma_outb(pagenr>>8, DMA_HI_PAGE_7);
  349.           break;
  350.     }
  351. }
  352.  
  353.  
  354. /* Set transfer address & page bits for specific DMA channel.
  355.  * Assumes dma flipflop is clear.
  356.  */
  357. static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int phys)
  358. {
  359.     if (dmanr <= 3)  {
  360.         dma_outb( phys & 0xff, ((dmanr&3)<<1) + IO_DMA1_BASE );
  361.             dma_outb( (phys>>8) & 0xff, ((dmanr&3)<<1) + IO_DMA1_BASE );
  362.     }  else  {
  363.       if (dmanr == SND_DMA1 || dmanr == SND_DMA2) {
  364.         dma_outb( phys  & 0xff, ((dmanr&3)<<2) + IO_DMA2_BASE );
  365.         dma_outb( (phys>>8)  & 0xff, ((dmanr&3)<<2) + IO_DMA2_BASE );
  366.         dma_outb( (dmanr&3), DMA2_EXT_REG);
  367.       } else {
  368.         dma_outb( (phys>>1) & 0xff, ((dmanr&3)<<2) + IO_DMA2_BASE );
  369.         dma_outb( (phys>>9) & 0xff, ((dmanr&3)<<2) + IO_DMA2_BASE );
  370.       }
  371.     }
  372.     set_dma_page(dmanr, phys>>16);
  373. }
  374.  
  375.  
  376. /* Set transfer size (max 64k for DMA1..3, 128k for DMA5..7) for
  377.  * a specific DMA channel.
  378.  * You must ensure the parameters are valid.
  379.  * NOTE: from a manual: "the number of transfers is one more
  380.  * than the initial word count"! This is taken into account.
  381.  * Assumes dma flip-flop is clear.
  382.  * NOTE 2: "count" represents _bytes_ and must be even for channels 5-7.
  383.  */
  384. static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
  385. {
  386.         count--;
  387.     if (dmanr <= 3)  {
  388.         dma_outb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
  389.         dma_outb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
  390.         } else {
  391.       if (dmanr == SND_DMA1 || dmanr == SND_DMA2) {
  392.         dma_outb( count & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
  393.         dma_outb( (count>>8) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
  394.       } else {
  395.         dma_outb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
  396.         dma_outb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
  397.       }
  398.         }
  399. }
  400.  
  401.  
  402. /* Get DMA residue count. After a DMA transfer, this
  403.  * should return zero. Reading this while a DMA transfer is
  404.  * still in progress will return unpredictable results.
  405.  * If called before the channel has been used, it may return 1.
  406.  * Otherwise, it returns the number of _bytes_ left to transfer.
  407.  *
  408.  * Assumes DMA flip-flop is clear.
  409.  */
  410. static __inline__ int get_dma_residue(unsigned int dmanr)
  411. {
  412.     unsigned int io_port = (dmanr<=3)? ((dmanr&3)<<1) + 1 + IO_DMA1_BASE
  413.                      : ((dmanr&3)<<2) + 2 + IO_DMA2_BASE;
  414.  
  415.     /* using short to get 16-bit wrap around */
  416.     unsigned short count;
  417.  
  418.     count = 1 + dma_inb(io_port);
  419.     count += dma_inb(io_port) << 8;
  420.     
  421.     return (dmanr <= 3 || dmanr == SND_DMA1 || dmanr == SND_DMA2)
  422.       ? count : (count<<1);
  423. }
  424.  
  425. /* These are in kernel/dma.c: */
  426. extern int request_dma(unsigned int dmanr, const char * device_id);    /* reserve a DMA channel */
  427. extern void free_dma(unsigned int dmanr);    /* release it again */
  428.  
  429. #ifdef CONFIG_PCI_QUIRKS
  430. extern int isa_dma_bridge_buggy;
  431. #else
  432. #define isa_dma_bridge_buggy    (0)
  433. #endif
  434.  
  435. #endif /* _ASM_DMA_H */
  436.